1
2
3
4
Neste
Finn indeksen til matriseelementet du vil fjerne ved hjelp av indexOf, og fjern deretter indeksen med spleisel.
Splice () -metoden endrer innholdet i en matrise ved å fjerne
eksisterende elementer og / eller legge til nye elementer.
const array = [2, 5, 9];
console.log (array);
const index = array.indexOf (5);
hvis (indeks> -1) {
array.splice (indeks, 1);
}
// array = [2, 9]
console.log (array);
Den andre parameteren for skjøting er antall elementer som skal fjernes. Merk at spleise endrer matrisen på plass og returnerer en ny matrise som inneholder elementene som er fjernet.
Av fullstendighetsgrunnen er her funksjoner. Den første funksjonen fjerner bare en enkelt forekomst (dvs. fjerner den første kampen på 5 fra [2,5,9,1,5,8,5]), mens den andre funksjonen fjerner alle forekomster:
funksjon removeItemOnce (arr, verdi) {
var indeks = arr.indexOf (verdi);
hvis (indeks> -1) {
arr.splice (indeks, 1);
}
retur arr;
}
funksjon removeItemAll (arr, verdi) {
var i = 0;
mens (i = 0; i--) {
hvis (matrise [i] === nummer) {
array.splice (i, 1);
}
}
Hvis du bare vil lage elementet i indeks, eksisterer jeg ikke lenger, men du vil ikke at indeksene til de andre elementene skal endres:
slett array [i];
|
Redigert 2016 oktober
Gjør det enkelt, intuitivt og eksplisitt (Occams barberhøvel)
Gjør det uforanderlig (originalt utvalg forblir uendret)
Gjør det med standard JavaScript-funksjoner, hvis nettleseren din ikke støtter dem - bruk polyfill
I dette kodeeksemplet bruker jeg funksjonen "array.filter (...)" for å fjerne uønskede elementer fra en matrise. Denne funksjonen endrer ikke den opprinnelige matrisen og oppretter en ny. Hvis nettleseren din ikke støtter denne funksjonen (f.eks. Internet Explorer før versjon 9 eller Firefox før versjon 1.5), bør du vurdere å bruke filterpolyfyllet fra Mozilla.
Fjerner element (ECMA-262 Edition 5-kode aka oldstyle JavaScript)
var verdi = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (funksjon (element) {
returvare! == verdi
})
console.log (arr)
// [1, 2, 4, 5]
Fjerner elementet (ECMAScript 6-kode)
la verdi = 3
la arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == verdi)
console.log (arr)
// [1, 2, 4, 5]
VIKTIG ECMAScript 6 "() => {}" syntaks for pilfunksjon støttes ikke i Internet Explorer i det hele tatt, Chrome før 45-versjonen, Firefox før 22-versjonen og Safari før 10-versjonen. For å bruke ECMAScript 6 syntaks i gamle nettlesere kan du bruke BabelJS.
Fjerne flere gjenstander (ECMAScript 7-kode)
En ekstra fordel med denne metoden er at du kan fjerne flere elementer
la forDeletion = [2, 3, 5]
la arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Les nedenfor om array.includes (...) support !!!
console.log (arr)
// [1, 4]
VIKTIG funksjonen "array.includes (...)" støttes ikke i Internet Explorer i det hele tatt, Chrome før 47-versjon, Firefox før 43-versjon, Safari før 9-versjon og Edge før 14-versjon, så her er polyfill fra Mozilla.
Fjerner flere elementer (i fremtiden, kanskje)
Hvis forslaget "Denne bindende syntaksen" noen gang blir akseptert, vil du kunne gjøre dette:
// array-lib.js
eksportfunksjon fjern (... forDeletion) {
returner dette.filteret (element =>! forDeletion.includes (item))
}
// main.js
importer {remove} fra './array-lib.js'
la arr = [1, 2, 3, 4, 5, 3]
// :: Dette bindende syntaksforslaget
// bruker "fjern" -funksjonen som "virtuell metode"
// uten å utvide Array.prototype
arr = arr :: fjern (2, 3, 5)
console.log (arr)
// [1, 4]
Prøv det selv i BabelJS :)
Referanse
Array.prototype.includes
Funksjonell sammensetning
|
Det kommer an på om du vil ha et tomt sted eller ikke.
Hvis du vil ha et tomt spor:
array [index] = udefinert;
Hvis du ikke vil ha et tomt spor:
// For å beholde originalen:
// oldArray = [... array];
// Dette endrer matrisen.
array.splice (indeks, 1);
Og hvis du trenger verdien av det elementet, kan du bare lagre elementet til den returnerte matrisen:
var verdi = array.splice (indeks, 1) [0];
Hvis du vil fjerne i hver ende av matrisen, kan du bruke array.pop () for den siste eller array.shift () for den første (begge returnerer også verdien av varen).
Hvis du ikke kjenner indeksen til varen, kan du bruke array.indexOf (item) for å få det (i et if () for å få ett element eller en stund () for å få dem alle). array.indexOf (item) returnerer enten indeksen eller -1 hvis den ikke blir funnet.
|
En venn hadde problemer i Internet Explorer 8 og viste meg hva han gjorde. Jeg fortalte ham at det var galt, og han fortalte meg at han fikk svarether. Gjeldende toppsvar fungerer ikke i alle nettlesere (for eksempel Internet Explorer 8), og det fjerner bare den første forekomsten av varen.
Fjern ALLE forekomster fra en matrise
funksjon array_remove_index_by_value (arr, element)
{
for (var i = arr. lengde; i--;)
{
hvis (arr [i] === vare) {arr.splice (i, 1);}
}
}
Den løper gjennom matrisen bakover (siden indekser og lengde vil endres når elementene fjernes) og fjerner elementet hvis det blir funnet. Det fungerer i alle nettlesere.
|
Det er to hovedtilnærminger:
spleising (): anArray.splice (indeks, 1);
slett: slett anArray [indeks];
Vær forsiktig når du bruker delete for en matrise. Det er bra for sletting av attributter til objekter, men ikke så bra for matriser. Det er bedre å bruke spleise til matriser.
Husk at når du bruker delete for en matrise, kan du få feil resultater for anArray.length. Med andre ord vil slette fjerne elementet, men det vil ikke oppdatere verdien av lengdeegenskapen.
Du kan også forvente å ha hull i indeksnummer etter bruk av delete, f.eks. du kan ende opp med å ha indeksene 1, 3, 4, 8, 9 og 11 og lengden slik den var før du brukte delete. I så fall vil alle indekserte for løkker krasje, siden indekser ikke lenger er sekvensielle.
Hvis du blir tvunget til å bruke slett av en eller annen grunn, bør du bruke for hver sløyfe når du trenger å gå gjennom matriser. Faktisk, unngå alltid å bruke indeksert for løkker, hvis mulig. På den måten ville koden være mer robust og mindre utsatt for problemer med indekser.
|
Array.prototype.remove_by_value = funksjon (val) {
for (var i = 0; i rad.id === 5);
var fjernet = helper.remove (arr, rad => rad.navn.startsWith ('BMW'));
##Definisjon
var hjelper = {
// Fjern og returner den første forekomsten
removeOne: funksjon (matrise, predikat) {
for (var i = 0; i [2, 3, 4]
|
Du kan bruke ES6. For eksempel for å slette verdien '3' i dette tilfellet:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((verdi) => verdi! = '3');
console.log (newArray);
Utgang:
["1", "2", "4", "5", "6"]
|
Hvis du vil ha en ny matrise med slettede posisjoner fjernet, kan du alltid slette det spesifikke elementet og filtrere ut matrisen. Det kan trenge en utvidelse av arrayobjektet for nettlesere som ikke implementerer filtermetoden, men på lang sikt er det lettere siden alt du gjør er dette:
var my_array = [1, 2, 3, 4, 5, 6];
slett min_array [4];
console.log (my_array.filter (funksjon (a) {return typeof a! == 'udefinert';}));
Den skal vise [1, 2, 3, 4, 6].
|
Her er noen måter å fjerne et element fra en matrise ved hjelp av JavaScript.
All den beskrevne metoden muterer ikke den opprinnelige matrisen, og oppretter i stedet en ny.
Hvis du kjenner indeksen til en vare
Anta at du har en matrise, og at du vil fjerne et element i posisjon i.
En metode er å bruke slice ():
const items = ['a', 'b', 'c', 'd', 'e', 'f']
konst i = 3
const filteredItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filteredItems)
slice () oppretter en ny matrise med indeksene den mottar. Vi oppretter ganske enkelt en ny matrise, fra start til indeksen vi vil fjerne, og sammenkoble en annen matrise fra første posisjon etter den vi fjernet til slutten av matrisen.
Hvis du vet verdien
I dette tilfellet er et godt alternativ å bruke filter (), som gir en mer deklarativ tilnærming:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (filteredItems)
Dette bruker ES6-pilfunksjonene. Du kan bruke de tradisjonelle funksjonene til å støtte eldre nettlesere:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter (funksjon (item) {
returvare! == valueToRemove
})
console.log (filteredItems)
eller du kan bruke Babel og transpileere ES6-koden tilbake til ES5 for å gjøre den mer fordøyelig for gamle nettlesere, men skriv moderne JavaScript i koden din.
Fjerner flere gjenstander
Hva om du i stedet for et enkelt element vil fjerne mange ting?
La oss finne den enkleste løsningen.
Etter indeks
Du kan bare opprette en funksjon og fjerne elementer i serien:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const removeItem = (items, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
la filteredItems = removeItem (elementer, 3)
filteredItems = removeItem (filteredItems, 5)
// ["a", "b", "c", "d"]
console.log (filteredItems)
Etter verdi
Du kan søke etter inkludering i tilbakeringingsfunksjonen:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Unngå å mutere den opprinnelige matrisen
splice () (ikke forveksles med slice ()) muterer den opprinnelige matrisen, og bør unngås.
(opprinnelig lagt ut på siden min https://flaviocopes.com/how-to-remove-item-from-array/)
|
Sjekk ut denne koden. Det fungerer i alle større nettlesere.
remove_item = funksjon (arr, verdi) {
var b = '';
for (b i arr) {
hvis (arr [b] === verdi) {
arr.spalte (b, 1);
gå i stykker;
}
}
retur arr;
};
Ring denne funksjonen
remove_item (matrise, verdi);
|
ES6 og uten mutasjon: (oktober 2016)
const removeByIndex = (liste, indeks) =>
[
... list.slice (0, indeks),
... list.slice (indeks + 1)
];
utgang = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (utdata)
|
Du kan bruke lodash _.pull (mutate array), _.pullAt (mutate array) eller _.without (ikke mutere array),
var array1 = ['a', 'b', 'c', 'd']
_.pull (array1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (array2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Fjerning av et bestemt element / streng fra en matrise kan gjøres i en en-linje:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
hvor:
theArray: matrisen du vil fjerne noe spesielt fra
stringToRemoveFromArray: strengen du vil fjerne og 1 er mengden elementer du vil fjerne.
MERK: Hvis "stringToRemoveFromArray" ikke ligger i arrayet ditt, fjernes dette siste elementet i arrayet.
Det er alltid god praksis å sjekke om elementet eksisterer i matrisen din før du fjerner det.
hvis (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Hvis du har tilgang til nyere Ecmascript-versjoner på klientens datamaskiner (ADVARSEL, fungerer kanskje ikke på eldre stasjoner):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((verdi) => verdi! = '3');
Hvor '3' er verdien du vil fjerne fra matrisen.
Matrisen ville da bli: ['1', '2', '4', '5', '6']
|
OK, for eksempel har du matrisen nedenfor:
var num = [1, 2, 3, 4, 5];
Og vi vil slette nummer 4. Du kan bare bruke koden nedenfor:
num.splice (num.indexOf (4), 1); // num vil være [1, 2, 3, 5];
Hvis du bruker denne funksjonen på nytt, skriver du en gjenbrukbar funksjon som blir knyttet til den opprinnelige matrisefunksjonen som nedenfor:
Array.prototype.remove = Array.prototype.remove || funksjon (x) {
const i = this.indexOf (x);
hvis (i === - 1)
komme tilbake;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Men hva med om du har matrisen nedenfor i stedet for noen [5] i matrisen?
var num = [5, 6, 5, 4, 5, 1, 5];
Vi trenger en løkke for å sjekke dem alle, men en enklere og mer effektiv måte er å bruke innebygde JavaScript-funksjoner, så vi skriver en funksjon som bruker et filter som nedenfor i stedet:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Det er også tredjepartsbiblioteker som hjelper deg med å gjøre dette, som Lodash eller Underscore. For mer informasjon, se lodash _.pull, _.pullAt eller _.without.
|
Opptreden
I dag (2019-12-09) gjennomfører jeg ytelsestester på macOS v10.13.6 (High Sierra) for valgte løsninger. Jeg viser delete (A), men jeg bruker den ikke i sammenligning med andre metoder, fordi den etterlot tom plass i matrisen.
Konklusjonene
den raskeste løsningen er array.splice (C) (unntatt Safari for små matriser der den har andre gang)
for store matriser er array.slice + splice (H) den raskeste uforanderlige løsningen for Firefox og Safari; Array.from (B) er raskest i Chrome
foranderlige løsninger er vanligvis 1,5x-6x raskere enn uforanderlige
for små bord på Safari, er den overraskende løsningen (C) langsommere enn den uforanderlige løsningen (G)
Detaljer
I tester fjerner jeg midtelementet fra matrisen på forskjellige måter. A, C-løsningene er på plass. B-, D-, E-, F-, G-, H-løsningene er uforanderlige.
Resultater for matrise med 10 elementer
I Chrome er array.splice (C) den raskeste løsningen på stedet. Array.filter (D) er den raskeste uforanderlige løsningen. Den tregeste er array.slice (F). Du kan utføre testen på maskinen din her.
Resultater for matrise med 1.000.000 elementer
I Chrome er array.splice (C) den raskeste løsningen på stedet (slettingen (C) er like rask - men den etterlot et tomt spor i matrisen (slik at den ikke utfører en fullstendig fjernelse)). Array.slice-splice (H) er den raskeste uforanderlige løsningen. Den tregeste er array.filter (D og E). Du kan utføre testen på maskinen din her.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
funksjon A (matrise) {
var index = array.indexOf (5);
slett matrise [indeks];
logg ('A', matrise);
}
funksjon B (matrise) {
var index = array.indexOf (5);
var arr = Array.from (array);
arr.splice (indeks, 1)
logg ('B', arr);
}
funksjon C (matrise) {
var index = array.indexOf (5);
array.splice (indeks, 1);
logg ('C', matrise);
}
funksjon D (matrise) {
var arr = array.filter (item => item! == 5)
logg ('D', arr);
}
funksjon E (matrise) {
var index = array.indexOf (5);
var arr = array.filter ((element, i) => i! == indeks)
logg ('E', arr);
}
funksjon F (matrise) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
logg ('F', arr);
}
funksjon G (matrise) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
logg ('G', arr);
}
funksjon H (matrise) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (indeks, 1);
logg ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
H ([... a]);
Denne kodebiten presenterer bare koden som brukes i ytelsestester - den utfører ikke selve testene.
Sammenligning for nettlesere: Chrome v78.0.0, Safari v13.0.4 og Firefox v71.0.0
|
Jeg er ganske ny på JavaScript og trengte denne funksjonaliteten. Jeg skrev bare dette:
funksjon removeFromArray (matrise, element, indeks) {
mens ((index = array.indexOf (item))> -1) {
array.splice (indeks, 1);
}
}
Så når jeg vil bruke den:
// Sett opp noen dummy-data
var dummyObj = {name: "mjau"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Fjern dummy-dataene
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Output - Som forventet.
["item1", "item1"]
Du kan ha andre behov enn jeg, så du kan enkelt endre detsom passer dem. Jeg håper dette hjelper noen.
|
Hvis du har komplekse objekter i matrisen, kan du bruke filtre?
I situasjoner der $ .inArray eller array.splice ikke er like lett å bruke. Spesielt hvis objektene kanskje er grunne i matrisen.
F.eks. hvis du har et objekt med et ID-felt og du vil at objektet skal fjernes fra en matrise:
this.array = this.array.filter (funksjon (element, i) {
return element.id! == idToRemove;
});
|
Jeg vil svare basert på ECMAScript 6. Anta at du har en matrise som nedenfor:
la arr = [1,2,3,4];
Hvis du vil slette ved en spesiell indeks som 2, skriver du koden nedenfor:
arr.splice (2, 1); // => arr ble [1,2,4]
Men hvis du vil slette et spesielt element som 3 og du ikke kjenner indeksen, gjør du nedenfor:
arr = arr.filter (e => e! == 3); // => arr ble [1,2,4]
Tips: bruk en pilfunksjon for å ringe tilbake med mindre du får en tom matrise.
|
Oppdatering: Denne metoden anbefales bare hvis du ikke kan bruke ECMAScript 2015 (tidligere kjent som ES6). Hvis du kan bruke den, gir andre svar her mye penere implementeringer.
Denne kjernen her vil løse problemet ditt, og sletter også alle forekomster av argumentet i stedet for bare 1 (eller en spesifisert verdi).
Array.prototype.destroy = funksjon (obj) {
// Return null hvis ingen gjenstander ble funnet og fjernet
var ødelagt = null;
for (var i = 0; i 3
x ødelegge (falsk); // => usann
x; // => [1, 2, sant, udefinert]
x ødelegge (sant); // => sant
x ødelegge (udefinert); // => udefinert
x; // => [1, 2]
x ødelegge (3); // => null
x; // => [1, 2]
|
ES10-oppdatering
Dette innlegget oppsummerer vanlige tilnærminger til fjerning av elementer fra matrisen fra ECMAScript 2019 (ES10).
1. Generelle saker
1.1. Fjerner Array-element etter verdi ved hjelp av .splice ()
| På stedet: Ja |
| Fjerner duplikater: Ja (loop), Nei (indexOf) |
| Etter verdi / indeks: Etter indeks |
Hvis du vet verdien du vil fjerne fra en matrise, kan du bruke spleisemetoden. Først må du identifisere indeksen til målelementet. Du bruker deretter indeksen som startelement og fjerner bare ett element.
// Med en 'for' løkke
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (la i = 0; i [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Med .indexOf () -metoden
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Fjern Array-element ved hjelp av .filter () -metoden
| På stedet: Nei |
| Fjerner duplikater: Ja |
| Etter verdi / indeks: Etter verdi |
Spesifikt element kan filtreres ut fra matrisen ved å gi filtreringsfunksjon. En slik funksjon kalles deretter for hvert element i matrisen.
const verdi = 3
la arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == verdi)
console.log (arr)
// [1, 2, 4, 5]
1.3. Fjern Array-elementet ved å utvide Array.prototype
| På stedet: Ja / Nei (avhenger av implementering) |
| Fjerner duplikater: Ja / Nei (avhenger av implementering) |
| Etter verdi / indeks: Etter indeks / Etter verdi (avhenger av implementering) |
Prototype of Array kan utvides med flere metoder. Slike metoder vil da være tilgjengelige for bruk på opprettede matriser.
Merk: Utvidelse av prototyper av gjenstander fra standard JavaScript-bibliotek (som Array) betraktes av noen som et antipatron.
// På stedet, fjerner alt, etter verdiimplementering
Array.prototype.remove = funksjon (element) {
for (la i = 0; i = ES10)
| På stedet: Nei |
| Fjerner duplikater: Ja |
| Etter verdi / indeks: Etter verdi |
ES10 introduserte Object.fromEntries, som kan værebrukes til å lage ønsket matrise fra ethvert array-lignende objekt og filtrere uønskede elementer under prosessen.
const objekt = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values (Object.fromEntries (
Object.entries (object)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Spesielle tilfeller
2.1 Fjerner elementet hvis det er på slutten av matrisen
2.1.1. Endrer matriselengde
| På stedet: Ja |
| Fjerner duplikater: Nei |
| Etter verdi / indeks: Ikke tilgjengelig |
JavaScript Array-elementer kan fjernes fra slutten av en matrise ved å sette lengdeegenskapen til en verdi som er mindre enn gjeldende verdi. Ethvert element hvis indeks er større enn eller lik den nye lengden, vil bli fjernet.
const arr = [1, 2, 3, 4, 5, 6];
arr. lengde = 5; // Still lengden for å fjerne elementet
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Bruker .pop () -metoden
| På stedet: Ja |
| Fjerner duplikater: Nei |
| Etter verdi / indeks: Ikke tilgjengelig |
Pop-metoden fjerner det siste elementet i matrisen, returnerer elementet og oppdaterer lengdeegenskapen. Pop-metoden endrer matrisen der den påkalles. Dette betyr at i motsetning til å slette, fjernes det siste elementet fullstendig og matriselengden reduseres.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // returnerer 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Fjerner elementet hvis det er i begynnelsen av matrisen
| På stedet: Ja |
| Fjerner duplikater: Nei |
| Etter verdi / indeks: Ikke tilgjengelig |
.Shift () -metoden fungerer omtrent som popmetoden, bortsett fra at den fjerner det første elementet i en JavaScript-matrise i stedet for den siste. Når elementet fjernes, flyttes de resterende elementene nedover.
const arr = [1, 2, 3, 4];
arr.skift (); // returnerer 1
console.log (arr); // [2, 3, 4]
2.3. Fjerner elementet hvis det er det eneste elementet i matrisen
| På stedet: Ja |
| Fjerner duplikater: N / A |
| Etter verdi / indeks: Ikke tilgjengelig |
Den raskeste teknikken er å sette en matrixvariabel til en tom matrise.
la arr = [1];
arr = []; // tom matrise
Alternativt kan teknikk fra 2.1.1 brukes ved å sette lengden til 0.
|
Du bør aldri mutere matrisen din. Da dette er i mot det funksjonelle programmeringsmønsteret. Du kan opprette en ny matrise uten å referere til matrisen du vil endre data for ved hjelp av ECMAScript 6-metodefilteret;
var myArray = [1, 2, 3, 4, 5, 6];
Anta at du vil fjerne 5 fra matrisen, du kan ganske enkelt gjøre det slik:
myArray = myArray.filter (verdi => verdi! == 5);
Dette vil gi deg en ny matrise uten verdien du ønsket å fjerne. Så resultatet blir:
[1, 2, 3, 4, 6]; // 5 er fjernet fra denne matrisen
For ytterligere forståelse kan du lese MDN-dokumentasjonen på Array.filter.
|
En mer moderne ECMAScript 2015 (tidligere kjent som Harmony eller ES 6) tilnærming. Gitt:
const items = [1, 2, 3, 4];
const indeks = 2;
Deretter:
items.filter ((x, i) => i! == indeks);
Gi fra seg:
[1, 2, 4]
Du kan bruke Babel og en polyfill-tjeneste for å sikre at dette støttes godt i alle nettlesere.
|
Du kan gjøre en bakoversløyfe for å sørge for ikke å skru opp indeksene, hvis det er flere forekomster av elementet.
var myElement = "sjokolade";
var myArray = ['sjokolade', 'poptart', 'poptart', 'poptart', 'sjokolade', 'poptart', 'poptart', 'sjokolade'];
/ * Viktig kode * /
for (var i = myArray.length - 1; i> = 0; i--) {
hvis (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Live Demo
|
Du har 1 til 9 i matrisen, og du vil fjerne 5. Bruk koden nedenfor:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
returner m! == 5;
});
console.log ("ny matrise, 5 fjernet", newNumberArray);
Hvis du vil ha flere verdier. Eksempel: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
retur (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("ny matrise, 1,7 og 8 fjernet", newNumberArray);
Hvis du vil fjerne en matriseverdi i en matrise. Eksempel: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
returner! removebleArray.includes (m);
});
console.log ("ny matrise, [3,4,5] fjernet", newNumberArray);
Inkluderer støttet nettleser er lenke.
|
1
2
3
4
Neste
Svært aktivt spørsmål. Tjen 10 rykte for å svare på dette spørsmålet. Omdømmekravet hjelper deg med å beskytte dette spørsmålet mot spam og ikke-svar-aktivitet.
Er ikke svaret du leter etter? Bla gjennom andre spørsmål merkede javascript-arrays, eller still dine egne spørsmål.